home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / linkedit / linkedit.lha / link-edit / LinkEdit / Link / link_rd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-03-13  |  8.7 KB  |  339 lines
  1. /* rd.c: File containing all the redrawing routines */
  2.  
  3.  
  4. #include <stdio.h>
  5. #include <math.h>
  6. #include <X11/Xlib.h>
  7. #include "link_types.h"
  8. #include "link_global.h"
  9.  
  10. ReDrawLinkTitleWindow(gnrc)
  11.  
  12. LinkStatus *gnrc;
  13.  
  14. {
  15.   XWindowAttributes xwa;
  16.   XWindowChanges xwc;
  17.   int x,y;
  18.  
  19.   if(gnrc->TitleWindow == (Window) 0) return(0);
  20.  
  21.   /* Redraw title */
  22.   /* Get information on TopWindow */
  23.  
  24.   XGetWindowAttributes(dpy,gnrc->TopWindow,&xwa);
  25.  
  26.   /* Change size of Title Bar to conform to new Top Window size */
  27.  
  28.   xwc.width = xwa.width;
  29.  
  30.   XConfigureWindow(dpy,gnrc->TitleWindow,(CWWidth),&xwc);
  31.  
  32.   x = (xwa.width - XTextWidth(gnrc->fontstruct,
  33.                                 gnrc->title,strlen(gnrc->title)))/2;
  34.   y = LINK_PAD + gnrc->fth;
  35.  
  36.   XDrawString(dpy,gnrc->TitleWindow,
  37.               gnrc->gc,x,y,gnrc->title,strlen(gnrc->title));
  38.  
  39.  
  40. }
  41.  
  42. ReDrawLinkMessageWindow(gnrc)
  43.  
  44. LinkStatus *gnrc;
  45.  
  46. {
  47.  
  48.   XWindowAttributes xwa;
  49.   XWindowChanges xwc;
  50.   int x,y;
  51.  
  52.   if(gnrc->MessageWindow == (Window) 0) return(0);
  53.  
  54.   /* Get information on TopWindow */
  55.   XGetWindowAttributes(dpy,gnrc->TopWindow,&xwa);
  56.  
  57.   /* Change size of Message Bar to conform to new Top Window size */
  58.  
  59.   xwc.width = xwa.width;
  60.  
  61.   XConfigureWindow(dpy,gnrc->MessageWindow,(CWWidth),&xwc);
  62.  
  63.   x = LINK_PAD;
  64.   y = LINK_PAD + gnrc->fth;
  65.  
  66.   XDrawString(dpy,gnrc->MessageWindow,gnrc->reverse_gc,
  67.               x,y,gnrc->message,strlen(gnrc->message));
  68.  
  69. }
  70.  
  71. LinkPrintMessage(gnrc,s)
  72.  
  73. LinkStatus *gnrc;
  74. char *s;
  75.  
  76. {
  77.   fprintf(stderr,"%s\n",s);
  78.   if(gnrc->MessageWindow == (Window) 0) return(0);
  79.   strcpy(gnrc->message,s);
  80.   XClearWindow(dpy,gnrc->MessageWindow);
  81.  
  82.   XDrawString(dpy,gnrc->MessageWindow,gnrc->reverse_gc,
  83.               LINK_PAD,LINK_PAD+gnrc->fth,s,strlen(s));
  84. }
  85.  
  86. ReDrawLinkTopWindow(gnrc)
  87.  
  88. LinkStatus *gnrc;
  89.  
  90. {
  91.   LinkList *lnk;
  92.   LinkPointList *pnt,sample;
  93.   int width,dcx,dcy;
  94.   char strng[20];
  95.   GC gc;
  96.  
  97.   if(gnrc->axes == LINK_SHOW) {
  98.      dcx = gnrc->origin.dcx;
  99.      dcy = gnrc->origin.dcy;
  100.      XDrawLine(dpy,gnrc->TopWindow,gnrc->gc,dcx,0,dcx,gnrc->height);
  101.      XDrawLine(dpy,gnrc->TopWindow,gnrc->gc,0,dcy,gnrc->width,dcy);
  102.     }
  103.  
  104.   if(gnrc->xruler == LINK_SHOW) {
  105.      dcx = sample.dcx = gnrc->hash_space/2; 
  106.      sample.dcy = 0;
  107.      if(gnrc->MessageWindow == (Window) 0) dcy = gnrc->height;
  108.      else dcy = gnrc->height - gnrc->fth - 2* LINK_PAD;
  109.  
  110.      while(dcx < gnrc->width) {
  111.         LinkComputePointWorldCoords(gnrc,&sample); 
  112.         sprintf(strng,"%+.3g",sample.x);
  113.         width = XTextWidth(gnrc->data_fontstruct,strng,strlen(strng));
  114.         XDrawString(dpy,gnrc->TopWindow,
  115.               gnrc->data_gc,dcx-width/2,dcy-gnrc->hash_height-LINK_PAD,
  116.               strng,strlen(strng));
  117.  
  118.         XDrawLine(dpy,gnrc->TopWindow,gnrc->data_gc,dcx,dcy,dcx,
  119.                            dcy-gnrc->hash_height);
  120.         dcx += gnrc->hash_space/2;
  121.  
  122.         XDrawLine(dpy,gnrc->TopWindow,gnrc->data_gc,dcx,dcy,dcx,
  123.                            dcy-gnrc->hash_height/2);
  124.         dcx += gnrc->hash_space/2;
  125.         sample.dcx = dcx;
  126.        }
  127.     }
  128.  
  129.   if(gnrc->yruler == LINK_SHOW) {
  130.      if(gnrc->MessageWindow == (Window) 0) 
  131.           dcy = sample.dcy = gnrc->height-gnrc->hash_height;
  132.      else dcy = sample.dcy = 
  133.             gnrc->height-gnrc->hash_space/2-gnrc->fth-2*LINK_PAD;
  134.      sample.dcx = 0;
  135.      dcx = 0; 
  136.  
  137.      while(dcy > 0) {
  138.         LinkComputePointWorldCoords(gnrc,&sample);
  139.         sprintf(strng,"%+.3g",sample.y);
  140.         XDrawString(dpy,gnrc->TopWindow,
  141.               gnrc->data_gc,dcx,dcy-LINK_PAD,strng,strlen(strng));
  142.  
  143.         XDrawLine(dpy,gnrc->TopWindow,gnrc->data_gc,dcx,dcy,
  144.                            dcx+gnrc->hash_height, dcy);
  145.                           
  146.         dcy -= gnrc->hash_space/2;
  147.  
  148.         XDrawLine(dpy,gnrc->TopWindow,gnrc->data_gc,dcx,dcy,
  149.                            dcx+gnrc->hash_height/2, dcy);
  150.                           
  151.         dcy -= gnrc->hash_space/2;
  152.         sample.dcy = dcy;
  153.        }
  154.     }
  155.   lnk = gnrc->link.next;
  156.   while(lnk != NULL) {
  157.      LinkDrawLink(gnrc,lnk);
  158.      lnk = lnk->next;
  159.     }
  160. }
  161.  
  162. LinkDrawLink(gnrc,lnk)
  163. LinkStatus *gnrc; LinkList *lnk;
  164.  
  165. {
  166.   GC gc;
  167.   LinkPointList *pnt;
  168.   int dcx,dcy;
  169.  
  170.   if(lnk->visible == LINK_HIDE) return;
  171.  
  172.   if(lnk == gnrc->current_link && gnrc->color_ok == 0){  /* Double point size */
  173.      gc = gnrc->data_gc;
  174.      if(gnrc->vertices == LINK_SHOW) {  /* Display vertices */
  175.         pnt = lnk->point.next;
  176.         while(pnt != NULL) {
  177.            dcx = pnt->dcx - LINK_POINT_X_SIZE;
  178.            dcy = pnt->dcy - LINK_POINT_Y_SIZE;
  179.            XFillRectangle(dpy,gnrc->TopWindow,gc,
  180.                       dcx,dcy,2*LINK_POINT_X_SIZE,2*LINK_POINT_Y_SIZE);
  181.            pnt = pnt->next;
  182.           }
  183.        }
  184.     }
  185.  
  186.   else {
  187.      if(lnk == gnrc->current_link) gc = gnrc->reverse_data_gc;
  188.      else gc = gnrc->data_gc;
  189.      if(gnrc->vertices == LINK_SHOW) {  /* Display vertices */
  190.         pnt = lnk->point.next;
  191.         while(pnt != NULL) {
  192.            dcx = pnt->dcx - LINK_POINT_X_SIZE/2;
  193.            dcy = pnt->dcy - LINK_POINT_Y_SIZE/2;
  194.            XFillRectangle(dpy,gnrc->TopWindow,gc,
  195.                       dcx,dcy,LINK_POINT_X_SIZE,LINK_POINT_Y_SIZE);
  196.            pnt = pnt->next;
  197.           }
  198.        }
  199.     }
  200.  
  201.   pnt = lnk->point.next;
  202.   while(pnt != NULL) {
  203.      LinkDrawEdge(gnrc,lnk,pnt);
  204.      pnt = pnt->next;
  205.     }
  206. }
  207.  
  208. LinkDrawPoint(gnrc,lnk,pnt)
  209. LinkStatus *gnrc; LinkList *lnk; LinkPointList *pnt;
  210. {
  211.   GC gc;
  212.   int dcx,dcy;
  213.  
  214.   if(gnrc->vertices != LINK_SHOW) return;
  215.  
  216.   if(lnk == gnrc->current_link && gnrc->color_ok == 0){  /* Double point size */
  217.      gc = gnrc->data_gc;
  218.      dcx = pnt->dcx - LINK_POINT_X_SIZE;
  219.      dcy = pnt->dcy - LINK_POINT_Y_SIZE;
  220.      XFillRectangle(dpy,gnrc->TopWindow,gc,
  221.                    dcx,dcy,2*LINK_POINT_X_SIZE,2*LINK_POINT_Y_SIZE);
  222.     }
  223.  
  224.   else {
  225.      if(lnk == gnrc->current_link) gc = gnrc->reverse_data_gc;
  226.      else gc = gnrc->data_gc;
  227.      dcx = pnt->dcx - LINK_POINT_X_SIZE/2;
  228.      dcy = pnt->dcy - LINK_POINT_Y_SIZE/2;
  229.      XFillRectangle(dpy,gnrc->TopWindow,gc,
  230.                 dcx,dcy,LINK_POINT_X_SIZE,LINK_POINT_Y_SIZE);
  231.     }
  232. }
  233.  
  234. LinkDrawEdge(gnrc,lnk,pnt)
  235. LinkStatus *gnrc;LinkList *lnk;LinkPointList *pnt;
  236.  
  237. {
  238.   GC gc;
  239.   LinkPointList *nxt;
  240.   LinkCrossingList *crossing;
  241.   int x0,y0,x1,y1;
  242.  
  243.   if(pnt == NULL) return(0);
  244.   if(pnt->next == NULL && lnk->closed == LINK_NO) return(0);
  245.  
  246.   if((nxt = pnt->next) == NULL) nxt =lnk->point.next;
  247.  
  248.   if(gnrc->color_ok && lnk == gnrc->current_link) 
  249.      gc = gnrc->reverse_data_gc;
  250.   else 
  251.      gc = gnrc->data_gc;
  252.  
  253.   if(gnrc->arrows) { /* Draw arrow */
  254.      x0 = pnt->dcx; y0 = pnt->dcy;
  255.      x1 = nxt->dcx; y1 = nxt->dcy;
  256.      LinkDrawArrow(gnrc,gc,(9*x0+x1)/10,(9*y0+y1)/10,x1-x0,y1-y0);
  257.     }
  258.      
  259.   if((crossing = pnt->crossing.next) == NULL) {
  260.        XDrawLine(dpy,gnrc->TopWindow,gc,pnt->dcx,pnt->dcy,
  261.                   nxt->dcx,nxt->dcy);
  262.     }
  263.   else {
  264.      int dcx,dcy,delta_x,delta_y;
  265.      double param,gamma,tmp_x,tmp_y;
  266.  
  267.      /* Compute crossing gap vector */
  268.      tmp_x = (double) (nxt->dcx - pnt->dcx)/xppmm;
  269.      tmp_y = (double) (nxt->dcy - pnt->dcy)/yppmm;
  270.      /* gamma = half fraction of total length devoted to each gap */
  271.      gamma = 0.5*LINK_GAP/sqrt(tmp_x*tmp_x + tmp_y*tmp_y);
  272.      delta_x = (int) (gamma * (double) (nxt->dcx - pnt->dcx));
  273.      delta_y = (int) (gamma * (double) (nxt->dcy - pnt->dcy));
  274.  
  275.      dcx = pnt->dcx; dcy = pnt->dcy;
  276.      param = 0;
  277.      while(crossing != NULL) {
  278.         if(crossing->z < 0) {
  279.            if(param < crossing->param - gamma) {
  280.               XDrawLine(dpy,gnrc->TopWindow,gc,dcx,dcy,
  281.                   crossing->dcx - delta_x,crossing->dcy - delta_y);
  282.              }
  283.            if((param = crossing->param + gamma) > 1.0) {
  284.               param = 1.0;
  285.               dcx = nxt->dcx; dcy = nxt->dcy;
  286.              }
  287.            else {
  288.               dcx = crossing->dcx + delta_x;dcy = crossing->dcy + delta_y;
  289.              }
  290.           }
  291.         crossing = crossing->next;
  292.        }
  293.  
  294.      /* Draw final part */
  295.      if(param < 1.0) {
  296.         XDrawLine(dpy,gnrc->TopWindow,gc,dcx,dcy,nxt->dcx,nxt->dcy);
  297.        }
  298.     }
  299. }
  300.  
  301. LinkDrawArrow(gnrc,gc,x,y,dx,dy)
  302. LinkStatus *gnrc;
  303. GC gc;
  304. int x,y,dx,dy;
  305.  
  306. /* Draw arrow at x,y in direction dx,dy */
  307. {
  308.   XPoint pnts[3];     /* The endpoints */
  309.   double norm,cs,sn;
  310.  
  311.   /* Compute the endpoints */
  312.  
  313.   norm = sqrt((double) (dx*dx + dy*dy));
  314.  
  315.   if(norm < 0.5) {    /* dx = dy = 0 */
  316.      return(0);
  317.     }
  318.  
  319.   cs = ((double) dx)/norm;
  320.   sn = ((double) dy)/norm;
  321.  
  322.   pnts[0].x = (short) x + (short) (LINK_ARROW_SIZE * cs *xppmm);
  323.   pnts[0].y = (short) y + (short) (LINK_ARROW_SIZE * sn *yppmm);;
  324.  
  325.   pnts[1].x = (short) x + (short) (0.5*LINK_ARROW_SIZE*(-sn)*xppmm);
  326.   pnts[1].y = (short) y + (short) (0.5*LINK_ARROW_SIZE*(cs)*yppmm);
  327.  
  328.   pnts[2].x = (short) x + (short) (0.5*LINK_ARROW_SIZE*(sn)*xppmm);
  329.   pnts[2].y = (short) y + (short) (0.5*LINK_ARROW_SIZE*(-cs)*yppmm); 
  330.  
  331.  
  332.   XFillPolygon(dpy,gnrc->TopWindow,
  333.                gc,pnts,
  334.                3,Convex,CoordModeOrigin);
  335.  
  336.   return(0);
  337. }
  338.  
  339.